using System;
using System.Collections.Generic;
using ns26;
using ns27;
using Triton.Game.Mono;

namespace Triton.Game.Mapping
{
	[Attribute38("ZoneMgr")]
	public class ZoneMgr : MonoBehaviour
	{
		[Attribute38("ZoneMgr.TempZone")]
		public class TempZone : MonoClass
		{
			public Zone m_zone => method_3<Zone>("m_zone");

			public bool m_modified => method_2<bool>("m_modified");

			public List<Entity> m_prevEntities => method_3<Class271<Entity>>("m_prevEntities")?.method_25();

			public List<Entity> m_entities => method_3<Class271<Entity>>("m_entities")?.method_25();

			public TempZone(IntPtr address, string className)
				: base(address, className)
			{
			}

			public TempZone(IntPtr address)
				: this(address, "TempZone")
			{
			}

			public Zone GetZone()
			{
				return method_14<Zone>("GetZone", Array.Empty<object>());
			}

			public void SetZone(Zone zone)
			{
				method_8("SetZone", zone);
			}

			public bool IsModified()
			{
				return method_11<bool>("IsModified", Array.Empty<object>());
			}

			public int GetEntityCount()
			{
				return method_11<int>("GetEntityCount", Array.Empty<object>());
			}

			public List<Entity> GetEntities()
			{
				return method_14<Class271<Entity>>("GetEntities", Array.Empty<object>())?.method_25();
			}

			public Entity GetEntityAtIndex(int index)
			{
				return method_14<Entity>("GetEntityAtIndex", new object[1] { index });
			}

			public Entity GetEntityAtPos(int pos)
			{
				return method_14<Entity>("GetEntityAtPos", new object[1] { pos });
			}

			public void ClearEntities()
			{
				method_8("ClearEntities");
			}

			public void AddInitialEntity(Entity entity)
			{
				method_8("AddInitialEntity", entity);
			}

			public bool CanAcceptEntity(Entity entity)
			{
				return method_11<bool>("CanAcceptEntity", new object[1] { entity });
			}

			public void AddEntity(Entity entity)
			{
				method_8("AddEntity", entity);
			}

			public void InsertEntityAtIndex(int index, Entity entity)
			{
				method_8("InsertEntityAtIndex", index, entity);
			}

			public void InsertEntityAtPos(int pos, Entity entity)
			{
				method_8("InsertEntityAtPos", pos, entity);
			}

			public bool RemoveEntity(Entity entity)
			{
				return method_11<bool>("RemoveEntity", new object[1] { entity });
			}

			public int GetLastPos()
			{
				return method_11<int>("GetLastPos", Array.Empty<object>());
			}

			public int FindEntityPos(Entity entity)
			{
				return method_10<int>("FindEntityPos", new Class276.Enum20[1] { Class276.Enum20.Class }, new object[1] { entity });
			}

			public bool ContainsEntity(Entity entity)
			{
				return method_10<bool>("ContainsEntity", new Class276.Enum20[1] { Class276.Enum20.Class }, new object[1] { entity });
			}

			public int FindEntityPos(int entityId)
			{
				return method_10<int>("FindEntityPos", new Class276.Enum20[1] { Class276.Enum20.I4 }, new object[1] { entityId });
			}

			public bool ContainsEntity(int entityId)
			{
				return method_10<bool>("ContainsEntity", new Class276.Enum20[1] { Class276.Enum20.I4 }, new object[1] { entityId });
			}

			public int FindEntityPosWithReplacements(int entityId)
			{
				return method_11<int>("FindEntityPosWithReplacements", new object[1] { entityId });
			}

			public void Sort()
			{
				method_8("Sort");
			}

			public void PreprocessChanges()
			{
				method_8("PreprocessChanges");
			}

			public void PostprocessChanges()
			{
				method_8("PostprocessChanges");
			}

			public new string ToString()
			{
				return method_13("ToString");
			}

			public int SortComparison(Entity entity1, Entity entity2)
			{
				return method_11<int>("SortComparison", new object[2] { entity1, entity2 });
			}
		}

		public List<Zone> m_zones => method_3<Class271<Zone>>("m_zones")?.method_25();

		public int m_nextLocalChangeListId => method_2<int>("m_nextLocalChangeListId");

		public int m_nextServerChangeListId => method_2<int>("m_nextServerChangeListId");

		public ZoneChangeList m_activeServerChangeList => method_3<ZoneChangeList>("m_activeServerChangeList");

		public List<ZoneChangeList> m_activeLocalChangeLists => method_3<Class271<ZoneChangeList>>("m_activeLocalChangeLists")?.method_25();

		public List<ZoneChangeList> m_pendingLocalChangeLists => method_3<Class271<ZoneChangeList>>("m_pendingLocalChangeLists")?.method_25();

		public float m_nextDeathBlockLayoutDelaySec => method_2<float>("m_nextDeathBlockLayoutDelaySec");

		public ZoneMgr(IntPtr address, string className)
			: base(address, className)
		{
		}

		public ZoneMgr(IntPtr address)
			: this(address, "ZoneMgr")
		{
		}

		public static ZoneMgr Get()
		{
			return MonoClass.smethod_15<ZoneMgr>(TritonHs.MainAssemblyPath, "", "ZoneMgr", "Get", Array.Empty<object>());
		}

		public static bool IsHandledPower(Network.PowerHistory power)
		{
			return MonoClass.smethod_14<bool>(TritonHs.MainAssemblyPath, "", "ZoneMgr", "IsHandledPower", new object[1] { power });
		}

		public void Awake()
		{
			method_8("Awake");
		}

		public void Start()
		{
			method_8("Start");
		}

		public void Update()
		{
			method_8("Update");
		}

		public void OnDestroy()
		{
			method_8("OnDestroy");
		}

		public List<Zone> GetZones()
		{
			return method_14<Class271<Zone>>("GetZones", Array.Empty<object>())?.method_25();
		}

		public Zone FindZoneForTags(int controllerId, TAG_ZONE zoneTag, TAG_CARDTYPE cardType)
		{
			return method_14<Zone>("FindZoneForTags", new object[3] { controllerId, zoneTag, cardType });
		}

		public Zone FindZoneForEntity(Entity entity)
		{
			return method_14<Zone>("FindZoneForEntity", new object[1] { entity });
		}

		public Zone FindZoneForEntityAndZoneTag(Entity entity, TAG_ZONE zoneTag)
		{
			return method_14<Zone>("FindZoneForEntityAndZoneTag", new object[2] { entity, zoneTag });
		}

		public Zone FindZoneForEntityAndController(Entity entity, int controllerId)
		{
			return method_14<Zone>("FindZoneForEntityAndController", new object[2] { entity, controllerId });
		}

		public Zone FindZoneForFullEntity(Network.HistFullEntity fullEntity)
		{
			return method_14<Zone>("FindZoneForFullEntity", new object[1] { fullEntity });
		}

		public Zone FindZoneForShowEntity(Entity entity, Network.HistShowEntity showEntity)
		{
			return method_14<Zone>("FindZoneForShowEntity", new object[2] { entity, showEntity });
		}

		public List<Zone> FindZonesForTag(TAG_ZONE zoneTag)
		{
			return method_14<Class271<Zone>>("FindZonesForTag", new object[1] { zoneTag })?.method_25();
		}

		public void RequestNextDeathBlockLayoutDelaySec(float sec)
		{
			method_8("RequestNextDeathBlockLayoutDelaySec", sec);
		}

		public float RemoveNextDeathBlockLayoutDelaySec()
		{
			return method_11<float>("RemoveNextDeathBlockLayoutDelaySec", Array.Empty<object>());
		}

		public int PredictZonePosition(Zone zone, int pos)
		{
			return method_11<int>("PredictZonePosition", new object[2] { zone, pos });
		}

		public bool HasPredictedCards()
		{
			return method_10<bool>("HasPredictedCards", new Class276.Enum20[0], Array.Empty<object>());
		}

		public bool HasPredictedPositions()
		{
			return method_11<bool>("HasPredictedPositions", Array.Empty<object>());
		}

		public bool HasActiveLocalChange()
		{
			return method_11<bool>("HasActiveLocalChange", Array.Empty<object>());
		}

		public bool HasPendingLocalChange()
		{
			return method_11<bool>("HasPendingLocalChange", Array.Empty<object>());
		}

		public bool HasTriggeredActiveLocalChange(Entity entity)
		{
			return method_10<bool>("HasTriggeredActiveLocalChange", new Class276.Enum20[1] { Class276.Enum20.Class }, new object[1] { entity });
		}

		public bool HasTriggeredActiveLocalChange(Card card)
		{
			return method_10<bool>("HasTriggeredActiveLocalChange", new Class276.Enum20[1] { Class276.Enum20.Class }, new object[1] { card });
		}

		public ZoneChangeList FindTriggeredActiveLocalChange(Entity entity)
		{
			return method_15<ZoneChangeList>("FindTriggeredActiveLocalChange", new Class276.Enum20[1] { Class276.Enum20.Class }, new object[1] { entity });
		}

		public ZoneChangeList FindTriggeredActiveLocalChange(Card card)
		{
			return method_15<ZoneChangeList>("FindTriggeredActiveLocalChange", new Class276.Enum20[1] { Class276.Enum20.Class }, new object[1] { card });
		}

		public bool HasTriggeredPendingLocalChange(Entity entity)
		{
			return method_10<bool>("HasTriggeredPendingLocalChange", new Class276.Enum20[1] { Class276.Enum20.Class }, new object[1] { entity });
		}

		public bool HasTriggeredPendingLocalChange(Card card)
		{
			return method_10<bool>("HasTriggeredPendingLocalChange", new Class276.Enum20[1] { Class276.Enum20.Class }, new object[1] { card });
		}

		public ZoneChangeList FindTriggeredPendingLocalChange(Entity entity)
		{
			return method_15<ZoneChangeList>("FindTriggeredPendingLocalChange", new Class276.Enum20[1] { Class276.Enum20.Class }, new object[1] { entity });
		}

		public ZoneChangeList FindTriggeredPendingLocalChange(Card card)
		{
			return method_15<ZoneChangeList>("FindTriggeredPendingLocalChange", new Class276.Enum20[1] { Class276.Enum20.Class }, new object[1] { card });
		}

		public bool IsChangeInLocalHistory(ZoneChangeList changeList)
		{
			return method_11<bool>("IsChangeInLocalHistory", new object[1] { changeList });
		}

		public ZoneChangeList AddLocalZoneChange(Card triggerCard, TAG_ZONE zoneTag)
		{
			return method_15<ZoneChangeList>("AddLocalZoneChange", new Class276.Enum20[2]
			{
				Class276.Enum20.Class,
				Class276.Enum20.ValueType
			}, new object[2] { triggerCard, zoneTag });
		}

		public ZoneChangeList AddLocalZoneChange(Card triggerCard, TAG_ZONE zoneTag, int destinationPos)
		{
			return method_15<ZoneChangeList>("AddLocalZoneChange", new Class276.Enum20[3]
			{
				Class276.Enum20.Class,
				Class276.Enum20.ValueType,
				Class276.Enum20.I4
			}, new object[3] { triggerCard, zoneTag, destinationPos });
		}

		public ZoneChangeList AddLocalZoneChange(Card triggerCard, Zone destinationZone, int destinationPos)
		{
			return method_15<ZoneChangeList>("AddLocalZoneChange", new Class276.Enum20[3]
			{
				Class276.Enum20.Class,
				Class276.Enum20.Class,
				Class276.Enum20.I4
			}, new object[3] { triggerCard, destinationZone, destinationPos });
		}

		public ZoneChangeList AddPredictedLocalZoneChange(Card triggerCard, Zone destinationZone, int destinationPos, int predictedPos)
		{
			return method_14<ZoneChangeList>("AddPredictedLocalZoneChange", new object[4] { triggerCard, destinationZone, destinationPos, predictedPos });
		}

		public void AddOldHeroCanceledChange(ZoneChangeList canceledChangeList, Card triggerCard)
		{
			method_8("AddOldHeroCanceledChange", canceledChangeList, triggerCard);
		}

		public bool HasActiveServerChange()
		{
			return method_11<bool>("HasActiveServerChange", Array.Empty<object>());
		}

		public bool HasPendingServerChange()
		{
			return method_11<bool>("HasPendingServerChange", Array.Empty<object>());
		}

		public void UpdateLocalChangeLists()
		{
			method_8("UpdateLocalChangeLists");
		}

		public void UpdateServerChangeLists()
		{
			method_8("UpdateServerChangeLists");
		}

		public bool HasLocalChangeExitingZone(Entity entity, Zone zone)
		{
			return method_10<bool>("HasLocalChangeExitingZone", new Class276.Enum20[2]
			{
				Class276.Enum20.Class,
				Class276.Enum20.Class
			}, new object[2] { entity, zone });
		}

		public void PredictZoneFromPowerProcessor(TempZone tempZone)
		{
			method_8("PredictZoneFromPowerProcessor", tempZone);
		}

		public void PredictZoneFromPowerTaskList(TempZone tempZone, PowerTaskList taskList)
		{
			method_8("PredictZoneFromPowerTaskList", tempZone, taskList);
		}

		public void PredictZoneFromPower(TempZone tempZone, Network.PowerHistory power)
		{
			method_8("PredictZoneFromPower", tempZone, power);
		}

		public void PredictZoneFromFullEntity(TempZone tempZone, Network.HistFullEntity fullEntity)
		{
			method_8("PredictZoneFromFullEntity", tempZone, fullEntity);
		}

		public void PredictZoneFromShowEntity(TempZone tempZone, Network.HistShowEntity showEntity)
		{
			method_8("PredictZoneFromShowEntity", tempZone, showEntity);
		}

		public void PredictZoneFromHideEntity(TempZone tempZone, Network.HistHideEntity hideEntity)
		{
			method_8("PredictZoneFromHideEntity", tempZone, hideEntity);
		}

		public void PredictZoneFromTagChange(TempZone tempZone, Network.HistTagChange tagChange)
		{
			method_8("PredictZoneFromTagChange", tempZone, tagChange);
		}

		public void PredictZoneByApplyingTag(TempZone tempZone, Entity tempEntity, GAME_TAG tag, int val)
		{
			method_8("PredictZoneByApplyingTag", tempZone, tempEntity, tag, val);
		}

		public void ProcessOrEnqueueLocalChangeList(ZoneChangeList changeList)
		{
			method_8("ProcessOrEnqueueLocalChangeList", changeList);
		}

		public void CreateLocalChangesFromTrigger(ZoneChangeList changeList, ZoneChange triggerChange)
		{
			method_9("CreateLocalChangesFromTrigger", new Class276.Enum20[2]
			{
				Class276.Enum20.Class,
				Class276.Enum20.Class
			}, changeList, triggerChange);
		}

		public void CreateLocalChangesFromTrigger(ZoneChangeList changeList, Entity triggerEntity, Zone sourceZone, TAG_ZONE sourceZoneTag, int sourcePos, Zone destinationZone, TAG_ZONE destinationZoneTag, int destinationPos)
		{
			method_9("CreateLocalChangesFromTrigger", new Class276.Enum20[8]
			{
				Class276.Enum20.Class,
				Class276.Enum20.Class,
				Class276.Enum20.Class,
				Class276.Enum20.ValueType,
				Class276.Enum20.I4,
				Class276.Enum20.Class,
				Class276.Enum20.ValueType,
				Class276.Enum20.I4
			}, changeList, triggerEntity, sourceZone, sourceZoneTag, sourcePos, destinationZone, destinationZoneTag, destinationPos);
		}

		public void CreateLocalPosOnlyChangesFromTrigger(ZoneChangeList changeList, Entity triggerEntity, Zone sourceZone, int sourcePos, int destinationPos)
		{
			method_8("CreateLocalPosOnlyChangesFromTrigger", changeList, triggerEntity, sourceZone, sourcePos, destinationPos);
		}

		public void ProcessLocalChangeList(ZoneChangeList changeList)
		{
			method_8("ProcessLocalChangeList", changeList);
		}

		public void OnCurrentPlayerChanged(Player player, object userData)
		{
			method_8("OnCurrentPlayerChanged", player, userData);
		}

		public void OnOptionRejected(Network.Options.Option option, object userData)
		{
			method_8("OnOptionRejected", option, userData);
		}

		public ZoneChangeList FindRejectedLocalZoneChange(Entity triggerEntity)
		{
			return method_14<ZoneChangeList>("FindRejectedLocalZoneChange", new object[1] { triggerEntity });
		}

		public ZoneChange CreateZoneChangeFromCreateGame(Network.HistCreateGame createGame)
		{
			return method_14<ZoneChange>("CreateZoneChangeFromCreateGame", new object[1] { createGame });
		}

		public ZoneChange CreateZoneChangeFromFullEntity(Network.HistFullEntity fullEntity)
		{
			return method_14<ZoneChange>("CreateZoneChangeFromFullEntity", new object[1] { fullEntity });
		}

		public ZoneChange CreateZoneChangeFromEntity(Network.Entity netEnt)
		{
			return method_14<ZoneChange>("CreateZoneChangeFromEntity", new object[1] { netEnt });
		}

		public ZoneChange CreateZoneChangeFromHideEntity(Network.HistHideEntity hideEntity)
		{
			return method_14<ZoneChange>("CreateZoneChangeFromHideEntity", new object[1] { hideEntity });
		}

		public ZoneChange CreateZoneChangeFromTagChange(Network.HistTagChange tagChange)
		{
			return method_14<ZoneChange>("CreateZoneChangeFromTagChange", new object[1] { tagChange });
		}

		public ZoneChange CreateZoneChangeFromMetaData(Network.HistMetaData metaData)
		{
			return method_14<ZoneChange>("CreateZoneChangeFromMetaData", new object[1] { metaData });
		}

		public Entity RegisterTempEntity(int id)
		{
			return method_15<Entity>("RegisterTempEntity", new Class276.Enum20[1] { Class276.Enum20.I4 }, new object[1] { id });
		}

		public Entity RegisterTempEntity(Network.Entity netEnt)
		{
			return method_15<Entity>("RegisterTempEntity", new Class276.Enum20[1] { Class276.Enum20.Class }, new object[1] { netEnt });
		}

		public Entity RegisterTempEntity(Entity entity)
		{
			return method_15<Entity>("RegisterTempEntity", new Class276.Enum20[1] { Class276.Enum20.Class }, new object[1] { entity });
		}

		public Entity RegisterTempEntity(int id, Entity entity)
		{
			return method_15<Entity>("RegisterTempEntity", new Class276.Enum20[2]
			{
				Class276.Enum20.I4,
				Class276.Enum20.Class
			}, new object[2] { id, entity });
		}

		public void PostProcessServerChangeList(ZoneChangeList serverChangeList)
		{
			method_8("PostProcessServerChangeList", serverChangeList);
		}

		public bool ShouldPostProcessServerChangeList(ZoneChangeList changeList)
		{
			return method_11<bool>("ShouldPostProcessServerChangeList", new object[1] { changeList });
		}

		public bool CheckAndIgnoreServerChangeList(ZoneChangeList serverChangeList)
		{
			return method_11<bool>("CheckAndIgnoreServerChangeList", new object[1] { serverChangeList });
		}

		public ZoneChangeList FindLocalChangeListMatchingServerChangeList(ZoneChangeList serverChangeList)
		{
			return method_14<ZoneChangeList>("FindLocalChangeListMatchingServerChangeList", new object[1] { serverChangeList });
		}

		public ZoneChange FindNextDstPosChange(ZoneChangeList changeList, int index, Entity entity)
		{
			return method_14<ZoneChange>("FindNextDstPosChange", new object[3] { changeList, index, entity });
		}

		public bool ReplaceRemoteWeaponInServerChangeList(ZoneChangeList serverChangeList)
		{
			return method_11<bool>("ReplaceRemoteWeaponInServerChangeList", new object[1] { serverChangeList });
		}

		public bool MergeServerChangeList(ZoneChangeList serverChangeList)
		{
			return method_11<bool>("MergeServerChangeList", new object[1] { serverChangeList });
		}

		public bool IsZoneInLocalHistory(Zone zone)
		{
			return method_11<bool>("IsZoneInLocalHistory", new object[1] { zone });
		}

		public void TempApplyZoneChange(ZoneChange change)
		{
			method_8("TempApplyZoneChange", change);
		}

		public TempZone BuildTempZone(Zone zone)
		{
			return method_14<TempZone>("BuildTempZone", new object[1] { zone });
		}

		public TempZone FindTempZoneForZone(Zone zone)
		{
			return method_14<TempZone>("FindTempZoneForZone", new object[1] { zone });
		}

		public int FindBestInsertionPosition(TempZone tempZone, int leftPos, int rightPos)
		{
			return method_11<int>("FindBestInsertionPosition", new object[3] { tempZone, leftPos, rightPos });
		}

		public int GetNextLocalChangeListId()
		{
			return method_11<int>("GetNextLocalChangeListId", Array.Empty<object>());
		}

		public int GetNextServerChangeListId()
		{
			return method_11<int>("GetNextServerChangeListId", Array.Empty<object>());
		}

		public int FindTriggeredActiveLocalChangeIndex(Entity entity)
		{
			return method_10<int>("FindTriggeredActiveLocalChangeIndex", new Class276.Enum20[1] { Class276.Enum20.Class }, new object[1] { entity });
		}

		public int FindTriggeredActiveLocalChangeIndex(Card card)
		{
			return method_10<int>("FindTriggeredActiveLocalChangeIndex", new Class276.Enum20[1] { Class276.Enum20.Class }, new object[1] { card });
		}

		public int FindTriggeredPendingLocalChangeIndex(Entity entity)
		{
			return method_10<int>("FindTriggeredPendingLocalChangeIndex", new Class276.Enum20[1] { Class276.Enum20.Class }, new object[1] { entity });
		}

		public int FindTriggeredPendingLocalChangeIndex(Card card)
		{
			return method_10<int>("FindTriggeredPendingLocalChangeIndex", new Class276.Enum20[1] { Class276.Enum20.Class }, new object[1] { card });
		}

		public void AutoCorrectZonesAfterServerChange()
		{
			method_8("AutoCorrectZonesAfterServerChange");
		}

		public void AutoCorrectZonesAfterLocalChange()
		{
			method_8("AutoCorrectZonesAfterLocalChange");
		}

		public void AutoCorrectZones()
		{
			method_8("AutoCorrectZones");
		}
	}
}
